﻿// 0725train02.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;

/*
题目描述
某学校举行运动，学生们按编号(1、2、3.....n) 进行标识,
现需要按照身高由低到高排列，对身高相同的人，按体重由轻到重排列，对于身高体重都相同的人，维持原有的编号顺序关系。
请输出排列后的学生编号

输入描述
两个序列，每个序列由 n 个正整数组成(0 < n < 100)。第一个序列中的数值代表身高，第二个序列中的数值代表体重。
输出描述
排列结果，每个数值都是原始序列中的学生编号，编号从 1 开始

4
100 100 120 130
40 30 60 50
*/

struct Stu {
    int id, height, weight;
    Stu(int id, int height, int weight) :id(id + 1), height(height), weight(weight) {};
};

bool CompareStu(const Stu& a, const Stu& b)
{
    if (a.height != b.height)
    {
        return a.height < b.height;
    }
    else if (a.weight != b.weight)
    {
        return a.weight < b.weight;
    }
    else {
        return a.id < b.id;
    }
}

void solve1(int total_c, vector<int>height_vec, vector<int>weight_vec)
{
    vector<Stu> result;
    for (int i = 0; i < height_vec.size(); i++)
    {
        int height = height_vec[i];
        int weight = weight_vec[i];
        Stu stu = { i, height, weight };

        result.push_back(stu);
    }
    sort(result.begin(), result.end(), CompareStu);

    for (auto& item : result)
    {
        cout << item.id;
    }
}


/*
题目描述
放暑假了，小明决定到某旅游景点游玩，他在网上搜索到了各种价位的酒店（长度为n的数组A），
他的心理价位是x元，请帮他筛选出k个最接近x元的酒店（n >= k > 0），并由低到高打印酒店的价格。

输入描述
第一行：n k x
第二行：A[0] A[1] A[2] … A[n-1]

输出描述
从低到高打印筛选出的酒店价格

数组长度10，5个最接近6元的酒店
10 5 6
1 2 3 4 5 6 7 8 9 10

4 5 6 7 8

思路1，先找出1个最近6元的

*/

struct HolNode {
    int id, value, diff;
    HolNode(int id, int value, int diff) :id(id), value(value), diff(diff) {};
};

bool Compare2(const HolNode& a, const HolNode& b)
{
    if (a.diff != b.diff)
    {
        return a.diff < b.diff;
    }
    else {
        return a.value < b.value;
    }
}

void solve2(int total, int k_count, int target, vector<int>hotel_vec)
{
    vector<HolNode>diff_vec;
    for (int i = 0; i < hotel_vec.size(); i++)
    {
        int item = hotel_vec[i];
        HolNode node = { i, item, abs(target - item) };
        diff_vec.push_back(node);
    }

    sort(diff_vec.begin(), diff_vec.end(), Compare2);

    vector<int>result_vec;
    for (int i = 0; i < k_count; i++)
    {
        HolNode item = diff_vec[i];
        result_vec.push_back(hotel_vec[item.id]);
        //cout << hotel_vec[item.id] << ' ';
    }

    sort(result_vec.begin(), result_vec.end());
    for (int i = 0; i < result_vec.size(); i++)
    {
        cout << result_vec[i] << ' ';
    }

}


/*
题目描述
给定一个射击比赛成绩单。包含多个选手若干次射击的成绩分数，请对每个选手按其最高三个分数之和进行降序排名。输出降序排名后的选手 ID 序列，条件如下:
1. 一个选手可以有多个射击成绩的分数 且次序不固定
2. 如果一个选手成绩小于三个 则认为选手的所有成绩无效，排名忽略该选手
3. 如果选手的成绩之和相等，则成绩相等的选手按照其 ID 降序排列

输入描述
输入第一行:一个整数 N
表示该场比赛总共进行了N次射击
产生 N 个成绩分数 2 <= N <= 100

输入第二行 一个长度为 N 的整数序列
表示参与本次射击的选手 Id
0 <= ID <= 99

输入第三行是长度为 N 的整数序列
表示参与每次射击的选手对应的成绩
0 <= 成绩 <= 100


输出描述
符合题设条件的降序排名后的选手 ID 序列

13
3,3,7,4,4,4,4,7,7,3,5,5,5
53,80,68,24,39,76,66,16,100,55,53,80,55

5,3,7,4
*/

struct ShootNode
{
    int id;
    int top_score;

    ShootNode(int id, int top_score) :id(id), top_score(top_score) {};
};

map<int, vector<int>>shoot_map;

bool Compare31(int a, int b)
{
    return a > b;
}

bool Compare32(ShootNode& a, ShootNode& b)
{
    if (a.top_score != b.top_score)
    {
        return a.top_score > b.top_score;
    }
    else {
        return a.id > b.id;
    }
}

void solve3(int total, vector<int>node_vec, vector<int>score_vec)
{
    for (int i = 0; i < node_vec.size(); i++)
    {
        int node_item = node_vec[i];
        int score_item = score_vec[i];

        if (!shoot_map.count(node_item))
        {
            shoot_map[node_item] = { score_item };
        }
        else {
            vector<int> tmp_vec = shoot_map[node_item];
            tmp_vec.push_back(score_item);
            shoot_map[node_item] = tmp_vec;
        }
    }

    vector<ShootNode>shoot_node_vec;
    for (auto& item : shoot_map)
    {
        int node_id = item.first;
        vector<int> node_vec = item.second;

        //小于三个,所有成绩无效
        if (node_vec.size() < 3) continue;

        sort(node_vec.begin(), node_vec.end(), Compare31);
        //最高三个分数之和
        int top_score = node_vec[0] + node_vec[1] + node_vec[2];

        ShootNode node_item = { node_id,top_score };
        shoot_node_vec.push_back(node_item);
    }

    
    sort(shoot_node_vec.begin(), shoot_node_vec.end(), Compare32);
    vector<int>result_vec;
    for (auto& item : shoot_node_vec)
    {
        result_vec.push_back(item.id);
        //cout << item.id << ' ';
        //cout << item.top_score << ' ';   
    }
    string result;
    for (int i = 0; i < result_vec.size(); i++)
    {
        int item = result_vec[i];
        if (i != result_vec.size() - 1)
        {
            result = result + to_string(item) + ',';
        }
        else {
            result += to_string(item);
        }
    }
    cout << result;
    
    //------
}



int main()
{
    //3------
    //-------
    {

        /*
        13
        3,3,7,4,4,4,4,7,7,3,5,5,5
        53,80,68,24,39,76,66,16,100,55,53,80,55

        5,3,7,4
        */
        
        string total_str;
        getline(cin, total_str);
        int total = stoi(total_str);

        vector<int>node_vec;
        string node_id_str;
        getline(cin, node_id_str);
        stringstream sstream1(node_id_str);
        string sstream1_str;
        while (getline(sstream1, sstream1_str, ','))
        {
            node_vec.push_back(stoi(sstream1_str));
        }
        
        vector<int>score_vec;
        string node_score_str;
        getline(cin, node_score_str);
        stringstream sstream2(node_score_str);
        string sstream2_str;
        while (getline(sstream2, sstream2_str, ','))
        {
            score_vec.push_back(stoi(sstream2_str));
        }

        /*for (auto& item : node_vec)
        {
            cout << item << ' ';
        }
        for (auto& item : score_vec)
        {
            cout << item << ' ';
        }*/

        /*
        int total = 13;
        vector<int>node_vec = { 3,3,7,4,4,4,4,7,7,3,5,5,5 };
        vector<int>score_vec = { 53,80,68,24,39,76,66,16,100,55,53,80,55 };
        solve3(total, node_vec, score_vec);
        */
        solve3(total, node_vec, score_vec);
        return 0;
        
    }



    //2------
    //-------
    {
        /*
        10 5 6
        1 2 3 4 5 6 7 8 9 10
        4 5 6 7 8
        */

        
        vector<int>basis_vec;
        string basis_str;
        getline(cin, basis_str);
        stringstream sstream1(basis_str);
        string basis_tmp;
        while (sstream1 >> basis_tmp)
        {
            basis_vec.push_back(stoi(basis_tmp));
        }

        vector<int>hotel_vec;
        string hotel_str;
        getline(cin, hotel_str);
        stringstream sstream2(hotel_str);
        string hotel_tmp;
        while (sstream2 >> hotel_tmp)
        {
            hotel_vec.push_back(stoi(hotel_tmp));
        }
        
        
        

        /*for (auto& item : basis_vec)
        {
            cout << item;
        }
        cout << '\n';
        for (auto& item : hotel_vec)
        {
            cout << item;
        }*/
        /*
        10 4 6
        10 9 8 7 6 5 4 3 2 1

        4 5 6 7
        */
        //vector<int>basis_vec = { 10, 4, 6 };
        //vector<int>hotel_vec = { 10,9,8,7,6,5,4,3,2,1 };
        int total = basis_vec[0];
        int k_count = basis_vec[1];
        int target = basis_vec[2];
        solve2(total, k_count, target, hotel_vec);

        return 0;
    }

    //1------
    //-------
    vector<int>height_vec;
    vector<int>weight_vec;
    string count_s;
    getline(cin, count_s);
    int count = stoi(count_s);

    string h_str;
    getline(cin, h_str);
    stringstream oh_sstream1(h_str);
    string h_str_i;
    while (oh_sstream1 >> h_str_i)
    {
        height_vec.push_back(stoi(h_str_i));
    }

    string w_str;
    getline(cin, w_str);
    stringstream oh_sstream2(w_str);
    string w_str_i;
    while (oh_sstream2 >> w_str_i)
    {
        weight_vec.push_back(stoi(w_str_i));
    }

    solve1(count, height_vec, weight_vec);

    /*for (auto& item : height_vec)
    {
        cout << item;
    }
    cout << '\n';
    for (auto& item : weight_vec)
    {
        cout << item;
    }*/
}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
